home *** CD-ROM | disk | FTP | other *** search
/ Kellogg's Amérique / Kellogg's Amérique / main.swf / scripts / fl / data / DataProvider.as next >
Text File  |  2020-08-04  |  10KB  |  302 lines
  1. package fl.data
  2. {
  3.    import fl.events.DataChangeEvent;
  4.    import fl.events.DataChangeType;
  5.    import flash.events.EventDispatcher;
  6.    
  7.    public class DataProvider extends EventDispatcher
  8.    {
  9.        
  10.       
  11.       protected var data:Array;
  12.       
  13.       public function DataProvider(param1:Object = null)
  14.       {
  15.          super();
  16.          if(param1 == null)
  17.          {
  18.             data = [];
  19.          }
  20.          else
  21.          {
  22.             data = getDataFromObject(param1);
  23.          }
  24.       }
  25.       
  26.       protected function dispatchPreChangeEvent(param1:String, param2:Array, param3:int, param4:int) : void
  27.       {
  28.          dispatchEvent(new DataChangeEvent(DataChangeEvent.PRE_DATA_CHANGE,param1,param2,param3,param4));
  29.       }
  30.       
  31.       public function invalidateItemAt(param1:int) : void
  32.       {
  33.          checkIndex(param1,data.length - 1);
  34.          dispatchChangeEvent(DataChangeType.INVALIDATE,[data[param1]],param1,param1);
  35.       }
  36.       
  37.       public function getItemIndex(param1:Object) : int
  38.       {
  39.          return data.indexOf(param1);
  40.       }
  41.       
  42.       protected function getDataFromObject(param1:Object) : Array
  43.       {
  44.          var _loc2_:Array = null;
  45.          var _loc3_:Array = null;
  46.          var _loc4_:uint = 0;
  47.          var _loc5_:Object = null;
  48.          var _loc6_:XML = null;
  49.          var _loc7_:XMLList = null;
  50.          var _loc8_:XML = null;
  51.          var _loc9_:XMLList = null;
  52.          var _loc10_:XML = null;
  53.          var _loc11_:XMLList = null;
  54.          var _loc12_:XML = null;
  55.          if(param1 is Array)
  56.          {
  57.             _loc3_ = param1 as Array;
  58.             if(_loc3_.length > 0)
  59.             {
  60.                if(_loc3_[0] is String || _loc3_[0] is Number)
  61.                {
  62.                   _loc2_ = [];
  63.                   _loc4_ = 0;
  64.                   while(_loc4_ < _loc3_.length)
  65.                   {
  66.                      _loc5_ = {
  67.                         "label":String(_loc3_[_loc4_]),
  68.                         "data":_loc3_[_loc4_]
  69.                      };
  70.                      _loc2_.push(_loc5_);
  71.                      _loc4_++;
  72.                   }
  73.                   return _loc2_;
  74.                }
  75.             }
  76.             return param1.concat();
  77.          }
  78.          if(param1 is DataProvider)
  79.          {
  80.             return param1.toArray();
  81.          }
  82.          if(param1 is XML)
  83.          {
  84.             _loc6_ = param1 as XML;
  85.             _loc2_ = [];
  86.             _loc7_ = _loc6_.*;
  87.             for each(_loc8_ in _loc7_)
  88.             {
  89.                param1 = {};
  90.                _loc9_ = _loc8_.attributes();
  91.                for each(_loc10_ in _loc9_)
  92.                {
  93.                   param1[_loc10_.localName()] = _loc10_.toString();
  94.                }
  95.                _loc11_ = _loc8_.*;
  96.                for each(_loc12_ in _loc11_)
  97.                {
  98.                   if(_loc12_.hasSimpleContent())
  99.                   {
  100.                      param1[_loc12_.localName()] = _loc12_.toString();
  101.                   }
  102.                }
  103.                _loc2_.push(param1);
  104.             }
  105.             return _loc2_;
  106.          }
  107.          throw new TypeError("Error: Type Coercion failed: cannot convert " + param1 + " to Array or DataProvider.");
  108.       }
  109.       
  110.       public function removeItemAt(param1:uint) : Object
  111.       {
  112.          var _loc2_:Array = null;
  113.          checkIndex(param1,data.length - 1);
  114.          dispatchPreChangeEvent(DataChangeType.REMOVE,data.slice(param1,param1 + 1),param1,param1);
  115.          _loc2_ = data.splice(param1,1);
  116.          dispatchChangeEvent(DataChangeType.REMOVE,_loc2_,param1,param1);
  117.          return _loc2_[0];
  118.       }
  119.       
  120.       public function addItem(param1:Object) : void
  121.       {
  122.          dispatchPreChangeEvent(DataChangeType.ADD,[param1],data.length - 1,data.length - 1);
  123.          data.push(param1);
  124.          dispatchChangeEvent(DataChangeType.ADD,[param1],data.length - 1,data.length - 1);
  125.       }
  126.       
  127.       public function sortOn(param1:Object, param2:Object = null) : *
  128.       {
  129.          var _loc3_:Array = null;
  130.          dispatchPreChangeEvent(DataChangeType.SORT,data.concat(),0,data.length - 1);
  131.          _loc3_ = data.sortOn(param1,param2);
  132.          dispatchChangeEvent(DataChangeType.SORT,data.concat(),0,data.length - 1);
  133.          return _loc3_;
  134.       }
  135.       
  136.       public function sort(... rest) : *
  137.       {
  138.          var _loc2_:Array = null;
  139.          dispatchPreChangeEvent(DataChangeType.SORT,data.concat(),0,data.length - 1);
  140.          _loc2_ = data.sort.apply(data,rest);
  141.          dispatchChangeEvent(DataChangeType.SORT,data.concat(),0,data.length - 1);
  142.          return _loc2_;
  143.       }
  144.       
  145.       public function addItems(param1:Object) : void
  146.       {
  147.          addItemsAt(param1,data.length);
  148.       }
  149.       
  150.       public function concat(param1:Object) : void
  151.       {
  152.          addItems(param1);
  153.       }
  154.       
  155.       public function clone() : DataProvider
  156.       {
  157.          return new DataProvider(data);
  158.       }
  159.       
  160.       public function toArray() : Array
  161.       {
  162.          return data.concat();
  163.       }
  164.       
  165.       public function get length() : uint
  166.       {
  167.          return data.length;
  168.       }
  169.       
  170.       public function addItemAt(param1:Object, param2:uint) : void
  171.       {
  172.          checkIndex(param2,data.length);
  173.          dispatchPreChangeEvent(DataChangeType.ADD,[param1],param2,param2);
  174.          data.splice(param2,0,param1);
  175.          dispatchChangeEvent(DataChangeType.ADD,[param1],param2,param2);
  176.       }
  177.       
  178.       public function getItemAt(param1:uint) : Object
  179.       {
  180.          checkIndex(param1,data.length - 1);
  181.          return data[param1];
  182.       }
  183.       
  184.       override public function toString() : String
  185.       {
  186.          return "DataProvider [" + data.join(" , ") + "]";
  187.       }
  188.       
  189.       public function invalidateItem(param1:Object) : void
  190.       {
  191.          var _loc2_:uint = 0;
  192.          _loc2_ = getItemIndex(param1);
  193.          if(_loc2_ == -1)
  194.          {
  195.             return;
  196.          }
  197.          invalidateItemAt(_loc2_);
  198.       }
  199.       
  200.       protected function dispatchChangeEvent(param1:String, param2:Array, param3:int, param4:int) : void
  201.       {
  202.          dispatchEvent(new DataChangeEvent(DataChangeEvent.DATA_CHANGE,param1,param2,param3,param4));
  203.       }
  204.       
  205.       protected function checkIndex(param1:int, param2:int) : void
  206.       {
  207.          if(param1 > param2 || param1 < 0)
  208.          {
  209.             throw new RangeError("DataProvider index (" + param1 + ") is not in acceptable range (0 - " + param2 + ")");
  210.          }
  211.       }
  212.       
  213.       public function addItemsAt(param1:Object, param2:uint) : void
  214.       {
  215.          var _loc3_:Array = null;
  216.          checkIndex(param2,data.length);
  217.          _loc3_ = getDataFromObject(param1);
  218.          dispatchPreChangeEvent(DataChangeType.ADD,_loc3_,param2,param2 + _loc3_.length - 1);
  219.          data.splice.apply(data,[param2,0].concat(_loc3_));
  220.          dispatchChangeEvent(DataChangeType.ADD,_loc3_,param2,param2 + _loc3_.length - 1);
  221.       }
  222.       
  223.       public function replaceItem(param1:Object, param2:Object) : Object
  224.       {
  225.          var _loc3_:int = 0;
  226.          _loc3_ = getItemIndex(param2);
  227.          if(_loc3_ != -1)
  228.          {
  229.             return replaceItemAt(param1,_loc3_);
  230.          }
  231.          return null;
  232.       }
  233.       
  234.       public function removeItem(param1:Object) : Object
  235.       {
  236.          var _loc2_:int = 0;
  237.          _loc2_ = getItemIndex(param1);
  238.          if(_loc2_ != -1)
  239.          {
  240.             return removeItemAt(_loc2_);
  241.          }
  242.          return null;
  243.       }
  244.       
  245.       public function merge(param1:Object) : void
  246.       {
  247.          var _loc2_:Array = null;
  248.          var _loc3_:uint = 0;
  249.          var _loc4_:uint = 0;
  250.          var _loc5_:uint = 0;
  251.          var _loc6_:Object = null;
  252.          _loc2_ = getDataFromObject(param1);
  253.          _loc3_ = _loc2_.length;
  254.          _loc4_ = data.length;
  255.          dispatchPreChangeEvent(DataChangeType.ADD,data.slice(_loc4_,data.length),_loc4_,this.data.length - 1);
  256.          _loc5_ = 0;
  257.          while(_loc5_ < _loc3_)
  258.          {
  259.             _loc6_ = _loc2_[_loc5_];
  260.             if(getItemIndex(_loc6_) == -1)
  261.             {
  262.                data.push(_loc6_);
  263.             }
  264.             _loc5_++;
  265.          }
  266.          if(data.length > _loc4_)
  267.          {
  268.             dispatchChangeEvent(DataChangeType.ADD,data.slice(_loc4_,data.length),_loc4_,this.data.length - 1);
  269.          }
  270.          else
  271.          {
  272.             dispatchChangeEvent(DataChangeType.ADD,[],-1,-1);
  273.          }
  274.       }
  275.       
  276.       public function replaceItemAt(param1:Object, param2:uint) : Object
  277.       {
  278.          var _loc3_:Array = null;
  279.          checkIndex(param2,data.length - 1);
  280.          _loc3_ = [data[param2]];
  281.          dispatchPreChangeEvent(DataChangeType.REPLACE,_loc3_,param2,param2);
  282.          data[param2] = param1;
  283.          dispatchChangeEvent(DataChangeType.REPLACE,_loc3_,param2,param2);
  284.          return _loc3_[0];
  285.       }
  286.       
  287.       public function invalidate() : void
  288.       {
  289.          dispatchEvent(new DataChangeEvent(DataChangeEvent.DATA_CHANGE,DataChangeType.INVALIDATE_ALL,data.concat(),0,data.length));
  290.       }
  291.       
  292.       public function removeAll() : void
  293.       {
  294.          var _loc1_:Array = null;
  295.          _loc1_ = data.concat();
  296.          dispatchPreChangeEvent(DataChangeType.REMOVE_ALL,_loc1_,0,_loc1_.length);
  297.          data = [];
  298.          dispatchChangeEvent(DataChangeType.REMOVE_ALL,_loc1_,0,_loc1_.length);
  299.       }
  300.    }
  301. }
  302.